# -*- coding: utf-8 -*-

 ###############################################
 ##                                             ##
 ##   Empresa Básica                             ##
 ##                                              ##
 ##                                              ##
 ##                                              ##
 ##   por Críptidos Digitales                    ##
 ##   GPL (c)2008                                ##
  ##                                             ##
    ###############################################

print (0), "reportes.administrador  begin"

from PyQt4 import QtCore, QtGui
# import ventas_ui
import capturaVenta_ui
# import detallesVenta_ui
import decimal
import utilities

# from cdWidgets import cdSlideFrame



CODIGO, NOMBRE, CLASIFICACION, CANTIDAD, PRECIO, IMPORTE = range(6)

print (0), "reportes.administrador    definitions"


class Forma(QtGui.QFrame):

    @property
    def owner(self):
        return self.__owner

    @property
    def mode(self):
        return self.__mode


    def __init__(self, *args, **kwds):
        print "Forma.__init__()"
        if kwds.has_key('owner'):
            self.__owner = kwds.pop('owner')
        else:
            self.__owner = None
        if kwds.has_key('data'):
            self.__old = kwds.pop('data')
        else:
            self.__old = None

        QtGui.QFrame.__init__(self, *args)

        self.ui = capturaVenta_ui.Ui_Form()
        self.ui.setupUi(self)

        self.setStyleSheet("background-color:#F8F8F8")

        completer = QtGui.QCompleter([], self.ui.edNombre)
        completer.setCaseSensitivity(QtCore.Qt.CaseInsensitive)
        QtCore.QObject.connect(completer, QtCore.SIGNAL("activated(QModelIndex)"), self.completerActivated)
        self.ui.edNombre.setCompleter(completer)
        QtCore.QObject.connect(self.ui.edNombre, QtCore.SIGNAL("textEdited(QString)"), self.nombreEditado)

        acompletadorRFC = QtGui.QCompleter([], self.ui.edRFC)
        acompletadorRFC.setCaseSensitivity(QtCore.Qt.CaseInsensitive)
        QtCore.QObject.connect(acompletadorRFC, QtCore.SIGNAL("activated(QModelIndex)"), self.acompletadorRFCActivado)
        self.ui.edRFC.setCompleter(acompletadorRFC)
        QtCore.QObject.connect(self.ui.edRFC, QtCore.SIGNAL("textEdited(QString)"), self.rfcEditado)

        self.ui.tablaPartidas.bd = self.owner.bd
        self.ui.tablaPartidas.modelo = modeloPartidas()
        QtCore.QObject.connect(self.ui.tablaPartidas.modelo, QtCore.SIGNAL("dataChanged(QModelIndex, QModelIndex)"), self.partidasDataChanged)
        self.ui.tablaPartidas.setModel(self.ui.tablaPartidas.modelo)
        self.ui.tablaPartidas.delegado = delegadoPartida()
        self.ui.tablaPartidas.setItemDelegate(self.ui.tablaPartidas.delegado)
        self.ui.tablaPartidas.horizontalHeader().setResizeMode(1, QtGui.QHeaderView.Stretch)
        QtCore.QObject.connect(self.ui.tablaPartidas, QtCore.SIGNAL("clicked(QModelIndex)"), self.partidasClicked)

        folio = str(int(self.owner.bd.get("variables", {'tipo':"ventas", 'nombre':"ultimoFolioFactura"})['valor']) + 1)
        self.ui.laFolio.setText(folio)
        self.ui.laFolio.setAlignment(QtCore.Qt.AlignCenter)

        self.ui.fecha.setDisplayFormat("dd MMM yyyy")
        self.ui.fecha.setDate(QtCore.QDate().currentDate())

        QtCore.QObject.connect(self.ui.cbTipoDocumento, QtCore.SIGNAL("currentIndexChanged(QString)"), self.tipoDocumentoCambiado)

        self.ui.cbTipoDocumento.clear()
        tipos = self.owner.bd.getMany("variables", {'tipo':"ventas", 'nombre':"tipoDocumento"})
        for tipo in tipos:
            self.ui.cbTipoDocumento.addItem(tipo['valor'], QtCore.QVariant(tipo['variable_id']))
        default = self.owner.bd.get("variables", {'tipo':"ventas", 'nombre':"tipoDocumentoDefault"})
        if default:
            self.ui.cbTipoDocumento.setCurrentIndex(self.ui.cbTipoDocumento.findText(default['valor']))

        if self.ui.cbTipoDocumento.currentText() == 'Factura':
            self.ui.tablaPartidas.model().precioConImpuesto = False
        elif self.ui.cbTipoDocumento.currentText() == 'Remision':
            self.ui.tablaPartidas.model().precioConImpuesto = True

        self.ui.laTotalConLetras.setText("")

        QtCore.QObject.connect(self.ui.edPago, QtCore.SIGNAL("editingFinished()"), self.pagoEditingFinished)


        # self.ui.slideDetalles = cdSlideFrame.CDSlideFrame(self.ui.tablaConsulta, self.ui.layout1, orientation="horizontal")
        # self.ui.slideDetalles.ui = detallesProducto_ui.Ui_Form()
        # self.ui.slideDetalles.ui.setupUi(self.ui.slideDetalles)
        # self.ui.slideDetalles.setStyleSheet("background-color:#EFEFEF")

        # self.ui.slideCaptura = cdSlideFrame.CDSlideFrame(self.ui.tablaConsulta, self.layout(), orientation="vertical")
        # self.ui.slideCaptura.ui = capturaProducto_ui.Ui_Form()
        # self.ui.slideCaptura.ui.setupUi(self.ui.slideCaptura)
        # self.ui.slideCaptura.ui.frame.setStyleSheet("background-color:#FFFFFF")

        # INICIALIZACION DE TABLA DE CONSULTA
        # self.ui.tablaConsulta.setSelectionMode(QtGui.QAbstractItemView.SingleSelection)
        # self.ui.tablaConsulta.setSelectionBehavior(QtGui.QAbstractItemView.SelectRows)
        # self.ui.tablaConsulta.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
        # self.ui.tablaConsulta.setColumnCount(5)
        # self.ui.tablaConsulta.setHorizontalHeaderLabels([u"Código", u"Nombre", u"Descripción", u"Costo", u"Precio"])
        # self.ui.tablaConsulta.horizontalHeader().setResizeMode(4, QtGui.QHeaderView.Stretch)
        # self.ui.tablaConsulta.setStyleSheet("background-color:#EFEFEF")
        # self.actualizarConsulta()
        # QtCore.QObject.connect(self.ui.tablaConsulta, QtCore.SIGNAL("itemDoubleClicked(QTableWidgetItem *)"), self.detalles)

        # MENU DE CONTEXTO DE TABLA DE CONSULTA
        # self.aAgregar = QtGui.QAction("Agregar", self)
        # self.aModificar = QtGui.QAction("Modificar", self)
        # self.aEliminar = QtGui.QAction("Eliminar", self)
        # self.menuTablaConsulta = QtGui.QMenu(self)
        # self.menuTablaConsulta.addAction(self.aAgregar)
        # self.menuTablaConsulta.addAction(self.aModificar)
        # self.menuTablaConsulta.addAction(self.aEliminar)
        # QtCore.QObject.connect(self.ui.tablaConsulta, QtCore.SIGNAL("customContextMenuRequested(QPoint)"), self.mostrarMenuConsulta)
        # QtCore.QObject.connect(self.aAgregar, QtCore.SIGNAL("triggered()"), self.agregar)
        # QtCore.QObject.connect(self.aModificar, QtCore.SIGNAL("triggered()"), self.modificar)
        # QtCore.QObject.connect(self.aEliminar, QtCore.SIGNAL("triggered()"), self.eliminar)

        # QtCore.QObject.connect(self.ui.boAgregar, QtCore.SIGNAL("clicked()"), self.agregar)
        # QtCore.QObject.connect(self.ui.boModificar, QtCore.SIGNAL("clicked()"), self.modificar)
        # QtCore.QObject.connect(self.ui.boEliminar, QtCore.SIGNAL("clicked()"), self.eliminar)

        QtCore.QObject.connect(self.ui.boGuardar, QtCore.SIGNAL("clicked()"), self.guardar)
        # QtCore.QObject.connect(self.ui.boCancelar, QtCore.SIGNAL("clicked()"), self.agregar)


    def pagoEditingFinished(self):
        cambio = self.ui.edPago.text().toDouble()[0] - self.ui.edTotal.text().toDouble()[0]
        self.ui.edCambio.setText("%s" % cambio)


    def recalcularPartidas(self):
        print "recalcularPartidas()"
        print self.ui.tablaPartidas.model().rowCount()
        for row in range(self.ui.tablaPartidas.model().rowCount()):
            print row
            print self.ui.tablaPartidas.model().ids
            if self.ui.tablaPartidas.model().ids[row] != -1:
                print self.ui.tablaPartidas.model().ids[row]
                producto = self.owner.bd.get("productos", {'producto_id':self.ui.tablaPartidas.model().ids[row]})
                if self.ui.tablaPartidas.model().precioConImpuesto:
                    precio = float(producto['precio'])
                else:
                    precio = float(producto['precio']) / 1.15
                index = self.ui.tablaPartidas.model().index(row, 4)
                self.ui.tablaPartidas.model().setData(index, QtCore.QVariant("%8.2f" % precio))

                index = self.ui.tablaPartidas.model().index(row, 3)
                print self.ui.tablaPartidas.model().data(index)
                importe = precio * self.ui.tablaPartidas.model().data(index).toDouble()[0]
                index = self.ui.tablaPartidas.model().index(row, 5)
                self.ui.tablaPartidas.model().setData(index, QtCore.QVariant("%8.2f" % importe))


    def tipoDocumentoCambiado(self, text):
        print "tipoDocumentoCambiado()"
        if text == 'Factura':
            self.ui.tablaPartidas.model().precioConImpuesto = False
        elif text == 'Remision':
            self.ui.tablaPartidas.model().precioConImpuesto = True
        self.recalcularPartidas()


    def acompletadorRFCActivado(self, completerModelIndex):
        cliente = self.owner.bd.get("clientes", {'cliente_id':self.ui.edRFC.completer().data[completerModelIndex.row()]})
        self.ui.edNombre.setText("%s %s" % (cliente['nombres'], cliente['apellidos']))
        self.ui.edCalle.setText(cliente['calle'])
        self.ui.edLugar.setText(cliente['lugar'])


    def rfcEditado(self, text):
        filtros = {}
        if text:
            filtros['rfc'] = "LIKE %s%%" % text
        clientes = self.owner.bd.getMany("clientes", filtros)
        ids = [x['cliente_id'] for x in clientes]
        rfcs = [x['rfc'] for x in clientes]
        self.ui.edRFC.completer().data = ids
        self.ui.edRFC.completer().model().setStringList(rfcs)


    def completerActivated(self, completerModelIndex):
        print "delegado.completerActivated()"
        cliente = self.owner.bd.get("clientes", {'cliente_id':self.ui.edNombre.completer().data[completerModelIndex.row()]})
        self.ui.edCalle.setText(cliente['calle'])
        self.ui.edLugar.setText(cliente['lugar'])
        self.ui.edRFC.setText(cliente['rfc'])


    def nombreEditado(self, text):
        print "nombreEditado()"
        filtros = {}
        if text:
            filtros['nombres'] = "LIKE %s%%" % text

        clientes = self.owner.bd.getMany("clientes", filtros)

        ids = [x['cliente_id'] for x in clientes]
        nombres = ["%s %s" % (x['nombres'], x['apellidos']) for x in clientes]

        self.ui.edNombre.completer().data = ids
        self.ui.edNombre.completer().model().setStringList(nombres)


    # def actualizarConsulta(self):
        # print "actualizarConsulta()"
        # datos = self.owner.bd.getMany("productos")
        # self.ui.tablaConsulta.setRowCount(0)
        # for index, dato in enumerate(datos):
            # self.ui.tablaConsulta.insertRow(index)
            # item = QtGui.QTableWidgetItem(dato['codigo'])
            # item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
            # item.setData(1000, QtCore.QVariant(dato['producto_id']))
            # self.ui.tablaConsulta.setItem(index, 0, item)

            # item = QtGui.QTableWidgetItem(dato['nombre'])
            # item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
            # self.ui.tablaConsulta.setItem(index, 1, item)

            # item = QtGui.QTableWidgetItem(dato['descripcion'])
            # item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
            # self.ui.tablaConsulta.setItem(index, 2, item)

            # item = QtGui.QTableWidgetItem(dato['costo'])
            # item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
            # self.ui.tablaConsulta.setItem(index, 3, item)

            # item = QtGui.QTableWidgetItem(dato['precio'])
            # item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
            # self.ui.tablaConsulta.setItem(index, 4, item)


            # self.ui.tablaConsulta.setItem(index, 0, QtGui.QTableWidgetItem(dato['codigo']))
            # self.ui.tablaConsulta.setItem(index, 1, QtGui.QTableWidgetItem(dato['nombre']))
            # self.ui.tablaConsulta.setItem(index, 2, QtGui.QTableWidgetItem(dato['descripcion']))
            # self.ui.tablaConsulta.setItem(index, 3, QtGui.QTableWidgetItem(dato['costo']))
            # self.ui.tablaConsulta.setItem(index, 4, QtGui.QTableWidgetItem(dato['precio']))
            # self.ui.tablaConsulta.item(index, 0).setData(1000, QtCore.QVariant(dato['producto_id']))


    # def agregar(self):
        # print "agregar()"
        # self.ui.slideCaptura.ui.titulo.setText(QtGui.QApplication.translate("Empresa Básica", "Alta de Producto", None, QtGui.QApplication.UnicodeUTF8))
        # self.__mode = "agregar"

        # self.ui.slideCaptura.ui.cbOrigen.clear()
        # self.ui.slideCaptura.ui.cbOrigen.addItem("Seleccione uno")
        # proveedores = self.owner.bd.getMany("proveedores")
        # for item in proveedores:
            # self.ui.slideCaptura.ui.cbOrigen.addItem("%s %s" % (item['nombre'], item['apellidos']))
        # self.toggle()


    def clear(self):
        self.ui.slideCaptura.ui.edCodigo.clear()
        self.ui.slideCaptura.ui.edNombre.clear()
        self.ui.slideCaptura.ui.edDescripcion.clear()


    # def detalles(self, item):
        # print "detalles"
        # item = self.ui.tablaConsulta.item(item.row(), 0)
        # data = self.owner.bd.get("productos", {'producto_id':item.data(1000).toInt()[0]})
        # self.ui.slideDetalles.ui.laCodigo.setText(data['codigo'])
        # self.ui.slideDetalles.ui.laNombre.setText(data['nombre'])
        # self.ui.slideDetalles.ui.laDescripcion.setText(data['descripcion'])
        # self.ui.slideDetalles.ui.laCosto.setText(data['costo'])
        # self.ui.slideDetalles.ui.laPrecio.setText(data['precio'])
        # self.ui.slideDetalles.start(200)


    def eliminar(self):
        if self.ui.tablaConsulta.currentRow() < 0:
            result = QtGui.QMessageBox.information(self, u"Empresa Básica - Eliminar producto", u"Seleccione el PRODUCTO que quiere ELIMINAR", QtGui.QMessageBox.Ok, QtGui.QMessageBox.Ok)
        else:
            id = self.ui.tablaConsulta.item(self.ui.tablaConsulta.currentRow(), 0).data(1000).toInt()[0]
            datos = self.owner.bd.get("productos", {'producto_id': id})
            result = QtGui.QMessageBox.warning(self, u"Empresa Básica - Eliminar producto", u"¿Realmente quieres ELIMINAR el PRODUCTO %s?" % datos['nombre'], QtGui.QMessageBox.Yes | QtGui.QMessageBox.No, QtGui.QMessageBox.No)
            if result == QtGui.QMessageBox.Yes:
                self.owner.bd.eliminar("productos", {'producto_id': id})
                self.actualizarConsulta()


    def esValida(self):
        valida = True
        self.mensajes = ""

        if not self.ui.slideCaptura.ui.edCodigo.isValid():
            valida = False
            self.mensajes += u"%s en el código\n" % self.ui.slideCaptura.ui.edCodigo.message()

        return valida


    def frameChanged(self, index):
        if self.ui.frame.status == None:
            self.ui.frame.setMaximumSize(QtCore.QSize(16777215, self.ui.frame.height - index))
        else:
            self.ui.frame.setMaximumSize(QtCore.QSize(16777215, index))


    def guardar(self):
        print "guardar()"
        datos = {}
        if self.esValida():
            datos['folio'] = unicode(self.ui.slideCaptura.ui.edFolio.text())
            datos['fecha'] = unicode(self.ui.slideCaptura.ui.fecha.text())
            datos['cliente'] = self.ui.slideCaptura.ui.cbOrigen.itemData(self.ui.slideCaptura.ui.cbOrigen.currentIndex()).toInt()[0]
            datos['subtotal'] = unicode(self.ui.slideCaptura.ui.edSubtotal.text())
            datos['descuentos'] = unicode(self.ui.slideCaptura.ui.edDescuentos.text())
            datos['impuestos'] = unicode(self.ui.slideCaptura.ui.edImpuestos.text())
            datos['total'] = unicode(self.ui.slideCaptura.ui.edTotal.text())
            datos['status'] = self.owner.bd.get("variables", {'tipo':"pedidos", 'nombre':"status", 'valor':"pendiente"})['variable_id']

            partidas = []
            model = self.ui.slideCaptura.ui.tablaPartidas.model()

            if self.mode == "agregar":
                self.owner.bd.modificar("variables", {'valor':datos['folio']}, {'tipo':"pedidos", 'nombre':"ultimoFolio"})
                self.owner.bd.agregar("pedidos", datos)
                pedido = self.owner.bd.get("pedidos", datos)
                for row in range(model.rowCount()):
                    print model.data(model.index(row, 0)).toString()
                    producto = self.owner.bd.get("productos", {'codigo':unicode(model.data(model.index(row, 0)).toString())})
                    print producto
                    if producto:
                        partida = {}
                        partida['pedido_id'] = pedido['pedido_id']
                        partida['producto_id'] = producto['producto_id']
                        partida['cantidad'] = unicode(model.data(model.index(row, 3)).toString())
                        partida['costo'] = producto['costo']
                        partida['precio'] = producto['precio']
                        partida['descuento'] = "0.00"
                        partida['status'] = self.owner.bd.get("variables", {'tipo':"pedidos", 'nombre':"status", 'valor':"pendiente"})['variable_id']
                        self.owner.bd.agregar("partidasPedido", partida)

            else:
                self.owner.bd.modificar("pedidos", datos, {'pedido_id':self.id})

            self.clear()
            self.toggle()
            self.actualizarConsulta()
        else:
            QtGui.QMessageBox.warning(self, u"Empresa Básica - Pedidos", u"%s" % self.mensajes, QtGui.QMessageBox.Ok)



    # def guardar(self):
        # datos = {}
        # if self.esValida():
            # datos['codigo'] = unicode(self.ui.slideCaptura.ui.edCodigo.text())
            # datos['nombre'] = unicode(self.ui.slideCaptura.ui.edNombre.text())
            # datos['descripcion'] = unicode(self.ui.slideCaptura.ui.edDescripcion.text())
            # datos['costo']  = unicode(self.ui.slideCaptura.ui.edCosto.text())
            # datos['precio'] = unicode(self.ui.slideCaptura.ui.edPrecio.text())

            # if self.mode == "agregar":
                # self.owner.bd.agregar("productos", datos)
            # else:
                # self.owner.bd.modificar("productos", datos, {'producto_id':self.id})

            # self.clear()
            # self.toggle()
            # self.actualizarConsulta()
        # else:
            # QtGui.QMessageBox.warning(self, u"Empresa Básica - Productos", u"%s" % self.mensajes, QtGui.QMessageBox.Ok)


    def modificar(self):
        if self.ui.tablaConsulta.currentRow() < 0:
            result = QtGui.QMessageBox.information(self, u"Empresa Básica - Modificar producto", u"Seleccione el PRODUCTO que quiere MODIFICAR", QtGui.QMessageBox.Ok, QtGui.QMessageBox.Ok)
        else:
            self.__mode = "modificacion"
            self.id = self.ui.tablaConsulta.item(self.ui.tablaConsulta.currentRow(), 0).data(1000).toInt()[0]
            datos = self.owner.bd.get("productos", {'producto_id': self.id})
            self.ui.slideCaptura.ui.edCodigo.setText(datos['codigo'])
            self.ui.slideCaptura.ui.edNombre.setText(datos['nombre'])
            self.ui.slideCaptura.ui.edDescripcion.setText(datos['descripcion'])
            self.ui.slideCaptura.ui.cbOrigen.setCurrentIndex(self.ui.cbOrigen.findData(1000, datos['origen']))
            self.ui.slideCaptura.ui.edCosto.setText(datos['costo'])
            self.ui.slideCaptura.ui.edMargen.setText(datos['margen'])
            self.ui.slideCaptura.ui.edPrecio.setText(datos['precio'])

            self.ui.slideCaptura.ui.titulo.setText(QtGui.QApplication.translate("Empresa Básica", "Modificación de Producto", None, QtGui.QApplication.UnicodeUTF8))
            self.toggle()


    def mostrarMenuConsulta(self, pos):
        pos = self.ui.tablaConsulta.mapToGlobal(pos)
        self.menuTablaConsulta.popup(pos)


    def partidasClicked(self, index):
        print "clicked()"
        self.ui.tablaPartidas.edit(index)


    def partidasDataChanged(self):
        print "partidasDataChanged()"
        subtotal = self.ui.tablaPartidas.model().subtotal()
        descuento = subtotal * 0.0
        self.ui.edSubtotal.setText("%8.2f" % subtotal)
        self.ui.edDescuentos.setText("%8.2f" % descuento)
        if self.ui.tablaPartidas.model().precioConImpuesto:
            impuesto = 0.00
        else:
            impuesto = subtotal * 0.15
        self.ui.edImpuestos.setText("%8.2f" % impuesto)
        total = subtotal - descuento + impuesto
        self.ui.edTotal.setText("%8.2f" % total)

        if total:
            self.ui.laTotalConLetras.setText("Son %s" % utilities.moneyToText(decimal.Decimal(str(total))))


    def toggle(self):
        self.ui.slideCaptura.start(300)




class delegadoPartida(QtGui.QItemDelegate):

    def __init__(self, parent=None):
        print "delegado.__init__()"
        QtGui.QItemDelegate.__init__(self, parent)
        # self.currentRow = 0


    def createEditor(self, parent, option, index):
        print "delegado.createEditor()", index.row(), index.column()
        # print parent.parent().currentIndex().row(), parent.parent().currentIndex().column()
        if index.row() == parent.parent().currentIndex().row():
            # print "    index.row() == self.currentRow [%s, %s]" % (index.row(), parent.parent().currentIndex().row())
            if index.column() == NOMBRE:
                # print "    column == NOMBRE"
                editor = QtGui.QLineEdit(parent)
                completer = QtGui.QCompleter([], editor)
                completer.setCaseSensitivity(QtCore.Qt.CaseInsensitive)
                QtCore.QObject.connect(completer, QtCore.SIGNAL("activated(QModelIndex)"), self.completerActivated)

                editor.setCompleter(completer)
                QtCore.QObject.connect(editor, QtCore.SIGNAL("textEdited(QString)"), self.textEdited)
                # QtCore.QObject.connect(editor, QtCore.SIGNAL("returnPressed()"), self.returnPressed)
            elif index.column() == CANTIDAD:
                editor = QtGui.QLineEdit(parent)
                editor.setAlignment(QtCore.Qt.AlignCenter|QtCore.Qt.AlignVCenter)
            elif index.column() == PRECIO:
                editor = QtGui.QLineEdit(parent)
                completer = QtGui.QCompleter([], editor)
                completer.setCaseSensitivity(QtCore.Qt.CaseInsensitive)
                QtCore.QObject.connect(completer, QtCore.SIGNAL("activated(QModelIndex)"), self.completerActivated)

                editor.setCompleter(completer)
                editor.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignVCenter)
                QtCore.QObject.connect(editor, QtCore.SIGNAL("textEdited(QString)"), self.textEdited)
            elif index.column() == IMPORTE:
                editor = None
            else:
                editor = QtGui.QLineEdit(parent)
                self.connect(editor, QtCore.SIGNAL("editingFinished()"), self.commitAndCloseEditor)
            QtCore.QObject.connect(editor, QtCore.SIGNAL("returnPressed()"), self.returnPressed)

            return editor


    def completerActivated(self, completerModelIndex):
        print "delegado.completerActivated()"
        tabla = self.sender().parent().parent().parent()

        tabla.model().ids[tabla.currentIndex().row()] = self.sender().data[completerModelIndex.row()]
        print tabla.currentIndex().row()
        print tabla.model().ids
        producto = tabla.bd.get("productos", {'producto_id':tabla.model().ids[tabla.currentIndex().row()]})
        tablaModelIndex = tabla.model().index(tabla.currentIndex().row(), CODIGO)
        tabla.model().setData(tablaModelIndex, QtCore.QVariant(producto['codigo']))

        tablaModelIndex = tabla.model().index(tabla.currentIndex().row(), NOMBRE)
        tabla.model().setData(tablaModelIndex, QtCore.QVariant(producto['nombre']))

        clasificacion = tabla.bd.get("variables", {'variable_id':producto['clasificacion']})['valor']
        tablaModelIndex = tabla.model().index(tabla.currentIndex().row(), CLASIFICACION)
        tabla.model().setData(tablaModelIndex, QtCore.QVariant(clasificacion))

        tablaModelIndex = tabla.model().index(tabla.currentIndex().row(), PRECIO)

        if tabla.model().precioConImpuesto:
            tabla.model().setData(tablaModelIndex, QtCore.QVariant("%8.2f" % float(producto['precio'])))
        else:
            tabla.model().setData(tablaModelIndex, QtCore.QVariant("%8.2f" % (float(producto['precio']) / 1.15)))

        tabla.resizeColumnToContents(CODIGO)
        tabla.resizeColumnToContents(CLASIFICACION)
        tabla.resizeColumnToContents(CANTIDAD)


    def returnPressed(self):
        print "delegado.returnPressed()"
        tabla = self.sender().parent().parent()
        print tabla.currentIndex().row()+1
        print tabla.model().rowCount()
        if tabla.currentIndex().row()+1 == tabla.model().rowCount():
            tablaModelIndex = tabla.model().index(tabla.currentIndex().row(), IMPORTE)
            print 12, tabla.model().data(tablaModelIndex).toString()
            if tabla.model().data(tablaModelIndex).toString():

                tabla.model().addRow()

                tablaModelIndex = tabla.model().index(tabla.currentIndex().row()+1, 1)
                tabla.setCurrentIndex(tablaModelIndex)
                tabla.edit(tablaModelIndex)


    def textEdited(self, text):
        print "delegado.textEdited()"
        filtros = {}
        if text:
            filtros['nombre'] = "LIKE %s%%" % text

        productos = self.sender().parent().parent().bd.getMany("productos", filtros)

        ids = [x['producto_id'] for x in productos]
        nombres = [x['nombre'] for x in productos]

        self.sender().completer().data = ids
        self.sender().completer().model().setStringList(nombres)


    def setEditorData(self, editor, index):
        print "delegado.setEditorData()"
        if index.row() == editor.parent().parent().currentIndex().row():
            print "    current row match"
            filtros = {}
            if editor.text():
                filtros['nombre'] = "LIKE %s%%" % editor.text()

            value = index.model().data(index, QtCore.Qt.DisplayRole).toString()
            print "        value", value
            editor.setText(value)


    def commitAndCloseEditor(self):
        print "delegado.commitAndCloseEditor()"
        editor = self.sender()
        if isinstance(editor, (QtGui.QLineEdit)):
            self.emit(QtCore.SIGNAL("commitData(QWidget*)"), editor)
            self.emit(QtCore.SIGNAL("closeEditor(QWidget*)"), editor)


    def setModelData(self, editor, model, index):
        print "delegado.setModelData()"
        if index.row() == editor.parent().parent().currentIndex().row():
            print "    current row match", index.row()
            if index.column() == NOMBRE:
                print "        column == NOMBRE"

                value = QtCore.QVariant(editor.text())
                model.setData(index, value)
            elif index.column() == CANTIDAD:
                print "        column == CANTIDAD"
                value = QtCore.QVariant(editor.text())
                print value
                model.setData(index, value)




class modeloPartidas(QtCore.QAbstractTableModel):

    def __init__(self):
        print "modeloPartidas().__init__()"
        QtCore.QAbstractTableModel.__init__(self)
        # self.__rowCount = 2
        self.__horizontalHeaderData = [u"Código", u"Nombre", u"Clasificación", u"Cantidad", u"Precio", u"Importe"]
        self.__verticalHeaderData = ["", "", "", "", ""]
        self.__data = [["", "", "", "", "", ""]]
        self.ids = [-1]


    def addRow(self, position=0):
        print "addRow()"
        position = len(self.__data)
        self.beginInsertRows(QtCore.QModelIndex(), position, position)
        self.__data.insert(position+1, ["", "", "", "", "", ""])
        self.ids.append(-1)
        self.endInsertRows()
        self.dirty = True
        self.reset()
        return True


    def removeRows(self, row, count, parent=QtCore.QModelIndex()):
        for index in range(count):
            self.__data.pop(row)


    def columnCount(self, parent=None):
        # print "modeloPartidas().columnCount()"
        return 6


    def data(self, index, role=QtCore.Qt.DisplayRole):
        # print "modeloPartidas().data()"
        if role == QtCore.Qt.DisplayRole:
            return QtCore.QVariant(self.__data[index.row()][index.column()])
        elif role == QtCore.Qt.TextAlignmentRole:
            if index.column() == CANTIDAD:
                return QtCore.QVariant(int(QtCore.Qt.AlignCenter|QtCore.Qt.AlignVCenter))
            if index.column() in [PRECIO, IMPORTE]:
                return QtCore.QVariant(int(QtCore.Qt.AlignRight|QtCore.Qt.AlignVCenter))
            return QtCore.QVariant(int(QtCore.Qt.AlignLeft|QtCore.Qt.AlignVCenter))
        else:
            return QtCore.QVariant()


    def flags(self, index):
        # print "modeloPartidas().flags()"
        if not index.isValid():
            return QtCore.Qt.ItemIsEnabled

        if index.column() == IMPORTE:
            return QtCore.Qt.NoItemFlags
        else:
            return QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsEditable


    def rowCount(self, parent=None):
        # print "modeloPartidas().rowCount()"
        return len(self.__data)


    def setData(self, index, value, role=QtCore.Qt.EditRole):
        print "modeloPartidas().setData()"
        ok = True
        if index.column() == CANTIDAD:
            cantidad, ok = value.toInt()
            if ok:
                precio = self.__data[index.row()][PRECIO]
                if precio:
                    importe = cantidad * float(precio)
                    self.__data[index.row()][IMPORTE] = "%8.2f" % importe
                    indexImporte = self.index(index.row(), 6)
                    self.emit(QtCore.SIGNAL("dataChanged(QModelIndex, QModelIndex)"), indexImporte, indexImporte)
            else:
                    self.__data[index.row()][IMPORTE] = ""
                    indexImporte = self.index(index.row(), 6)
                    self.emit(QtCore.SIGNAL("dataChanged(QModelIndex, QModelIndex)"), indexImporte, indexImporte)
        self.__data[index.row()][index.column()] = value.toString()
        self.emit(QtCore.SIGNAL("dataChanged(QModelIndex, QModelIndex)"), index, index)
        return True


    def headerData(self, section, orientation, role):
        # print "modeloPartidas().headerData()"
        if role != QtCore.Qt.DisplayRole:
            return QtCore.QVariant()

        if orientation == QtCore.Qt.Horizontal:
            # print "Horizontal"
            return QtCore.QVariant(self.__horizontalHeaderData[section])
        else:
            # print "non Horizontal"
            return QtCore.QVariant(self.__verticalHeaderData[section])


    def subtotal(self):
        subtotal = 0.0
        for rowData in self.__data:
            if rowData[5]:
                subtotal += float(rowData[5])
        return subtotal




print (0), "reportes.administrador  end"



